SQLAlchemy Core vs ORM: detalizēts vaicājumu veidošanas salīdzinājums

SQLAlchemy ir jaudīgs un elastīgs SQL rīku komplekts un objektu relāciju kartētājs (ORM) programmēšanas valodai Python. Tas piedāvā divus atšķirīgus veidus, kā mijiedarboties ar datubāzēm: SQLAlchemy Core un SQLAlchemy ORM. Izpratne par atšķirībām starp šīm pieejām ir būtiska, lai izvēlētos pareizo rīku jūsu konkrētajām vajadzībām. Šis raksts sniedz visaptverošu salīdzinājumu par vaicājumu veidošanu, izmantojot gan SQLAlchemy Core, gan ORM, koncentrējoties uz veiktspēju, elastību un lietošanas ērtumu.

Izpratne par SQLAlchemy Core

SQLAlchemy Core nodrošina tiešu un skaidru veidu, kā mijiedarboties ar datubāzēm. Tas ļauj jums definēt datubāzes tabulas un tieši izpildīt SQL priekšrakstus. Būtībā tas ir abstrakcijas slānis virs datubāzes dabiskā SQL dialekta, nodrošinot Python stilam atbilstošu veidu, kā veidot un izpildīt SQL.

Galvenās SQLAlchemy Core iezīmes:

• Skaidrs SQL: Jūs rakstāt SQL priekšrakstus tieši, kas sniedz jums precīzu kontroli pār datubāzes mijiedarbību.
• Zemāka līmeņa abstrakcija: Nodrošina plānu abstrakcijas slāni, samazinot papildu slodzi un maksimizējot veiktspēju.
• Fokuss uz datiem: Galvenokārt strādā ar datu rindām kā vārdnīcām vai kortežiem.
• Lielāka elastība: Piedāvā maksimālu elastību sarežģītiem vaicājumiem un datubāzei specifiskām funkcijām.

Izpratne par SQLAlchemy ORM

SQLAlchemy ORM (objektu relāciju kartētājs) nodrošina augstāka līmeņa abstrakcijas slāni, ļaujot jums mijiedarboties ar datubāzi, izmantojot Python objektus. Tas kartē datubāzes tabulas uz Python klasēm, ļaujot jums strādāt ar datiem objektorientētā veidā.

Galvenās SQLAlchemy ORM iezīmes:

• Objektorientēts: Mijiedarbojas ar datiem, izmantojot Python objektus, kas attēlo datubāzes rindas.
• Augstāka līmeņa abstrakcija: Automatizē daudzas datubāzes operācijas, vienkāršojot izstrādi.
• Fokuss uz objektiem: Apstrādā datus kā objektus, nodrošinot iekapsulēšanu un mantošanu.
• Vienkāršota izstrāde: Vienkāršo bieži veicamus datubāzes uzdevumus un samazina šablona koda daudzumu.

Datubāzes iestatīšana (kopīgais pamats)

Pirms salīdzināt vaicājumu veidošanu, iestatīsim vienkāršu datubāzes shēmu, izmantojot SQLAlchemy. Demonstrācijas nolūkos izmantosim SQLite, bet šie koncepti attiecas arī uz citām datubāzu sistēmām (piemēram, PostgreSQL, MySQL, Oracle) ar nelielām dialektam specifiskām korekcijām. Mēs izveidosim `users` tabulu ar kolonnām `id`, `name` un `email`.

Vispirms instalējiet SQLAlchemy:

            pip install sqlalchemy
            

              
                Copy
              
            
          

Tagad definēsim tabulu, izmantojot gan Core, gan ORM pieeju. Šī sākotnējā iestatīšana parāda fundamentālo atšķirību, kā tiek definētas tabulas.

Core iestatīšana

            from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String

engine = create_engine('sqlite:///:memory:') # In-memory database for example
metadata = MetaData()

users_table = Table(
    'users',
    metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(50)),
    Column('email', String(100))
)

metadata.create_all(engine)

connection = engine.connect()
            

              
                Copy
              
            
          

ORM iestatīšana

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

engine = create_engine('sqlite:///:memory:')
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    email = Column(String(100))

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()
            

              
                Copy
              
            
          

Core piemērā mēs definējam tabulu tieši, izmantojot `Table` klasi. ORM piemērā mēs definējam Python klasi `User`, kas tiek kartēta uz `users` tabulu. ORM izmanto deklaratīvo bāzi, lai definētu tabulas struktūru caur klases definīciju.

Vaicājumu veidošanas salīdzinājums

Tagad salīdzināsim, kā veidot vaicājumus, izmantojot SQLAlchemy Core un ORM. Mēs apskatīsim bieži sastopamas vaicājumu operācijas, piemēram, datu atlasīšanu, filtrēšanu, ievietošanu, atjaunināšanu un dzēšanu.

Datu atlasīšana

SQLAlchemy Core:

            from sqlalchemy import select

# Select all users
select_stmt = select(users_table)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)

# Select specific columns (name and email)
select_stmt = select(users_table.c.name, users_table.c.email)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Select all users
users = session.query(User).all()

for user in users:
    print(user.name, user.email)

# Select specific columns (name and email)
users = session.query(User.name, User.email).all()

for user in users:
    print(user)
            

              
                Copy
              
            
          

Core gadījumā jūs izmantojat `select` funkciju un norādāt tabulu vai kolonnas, kuras atlasīt. Jūs piekļūstat kolonnām, izmantojot `users_table.c.column_name`. Rezultāts ir kortežu saraksts, kas attēlo rindas. ORM gadījumā jūs izmantojat `session.query(User)`, lai atlasītu visus lietotājus, un piekļūstat kolonnām, izmantojot objektu atribūtus (piemēram, `user.name`). Rezultāts ir `User` objektu saraksts. Ievērojiet, ka ORM automātiski veic tabulas kolonnu kartēšanu uz objektu atribūtiem.

Datu filtrēšana (WHERE klauzula)

SQLAlchemy Core:

            from sqlalchemy import select, and_, or_

# Select users with name 'Alice'
select_stmt = select(users_table).where(users_table.c.name == 'Alice')
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)

# Select users with name 'Alice' and email containing 'example.com'
select_stmt = select(users_table).where(
    and_(
        users_table.c.name == 'Alice',
        users_table.c.email.like('%example.com%')
    )
)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Select users with name 'Alice'
users = session.query(User).filter(User.name == 'Alice').all()

for user in users:
    print(user.name, user.email)

# Select users with name 'Alice' and email containing 'example.com'
users = session.query(User).filter(
    User.name == 'Alice',
    User.email.like('%example.com%')
).all()

for user in users:
    print(user.name, user.email)
            

              
                Copy
              
            
          

Core gadījumā jūs izmantojat `where` klauzulu, lai filtrētu datus. Jūs varat izmantot loģiskos operatorus, piemēram, `and_` un `or_`, lai apvienotu nosacījumus. ORM gadījumā jūs izmantojat `filter` metodi, kas nodrošina objektorientētāku veidu, kā norādīt filtra nosacījumus. Vairāki `filter` izsaukumi ir līdzvērtīgi `and_` izmantošanai.

Datu kārtošana (ORDER BY klauzula)

SQLAlchemy Core:

            from sqlalchemy import select

# Select users ordered by name (ascending)
select_stmt = select(users_table).order_by(users_table.c.name)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)

# Select users ordered by name (descending)
from sqlalchemy import desc
select_stmt = select(users_table).order_by(desc(users_table.c.name))
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Select users ordered by name (ascending)
users = session.query(User).order_by(User.name).all()

for user in users:
    print(user.name, user.email)

# Select users ordered by name (descending)
from sqlalchemy import desc
users = session.query(User).order_by(desc(User.name)).all()

for user in users:
    print(user.name, user.email)
            

              
                Copy
              
            
          

Gan Core, gan ORM gadījumā jūs izmantojat `order_by` klauzulu, lai kārtotu rezultātus. Jūs varat izmantot `desc` funkciju, lai norādītu dilstošu secību. Sintakse ir ļoti līdzīga, bet ORM izmanto objektu atribūtus kolonnu atsaucēm.

Rezultātu ierobežošana (LIMIT un OFFSET klauzulas)

SQLAlchemy Core:

            from sqlalchemy import select

# Select the first 5 users
select_stmt = select(users_table).limit(5)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)

# Select users starting from the 6th user (offset 5), limit 5
select_stmt = select(users_table).offset(5).limit(5)
result = connection.execute(select_stmt)
users = result.fetchall()

for user in users:
    print(user)
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Select the first 5 users
users = session.query(User).limit(5).all()

for user in users:
    print(user.name, user.email)

# Select users starting from the 6th user (offset 5), limit 5
users = session.query(User).offset(5).limit(5).all()

for user in users:
    print(user.name, user.email)
            

              
                Copy
              
            
          

Gan Core, gan ORM izmanto `limit` un `offset` metodes, lai kontrolētu atgriezto rezultātu skaitu. Sintakse ir gandrīz identiska.

Tabulu savienošana (JOIN klauzula)

Tabulu savienošana ir sarežģītāka operācija, kas izceļ atšķirības starp Core un ORM. Pieņemsim, ka mums ir otra tabula ar nosaukumu `addresses` ar kolonnām `id`, `user_id` un `address`.

SQLAlchemy Core:

            from sqlalchemy import Table, Column, Integer, String, ForeignKey

addresses_table = Table(
    'addresses',
    metadata,
    Column('id', Integer, primary_key=True),
    Column('user_id', Integer, ForeignKey('users.id')),
    Column('address', String(200))
)

metadata.create_all(engine)

# Select users and their addresses
select_stmt = select(users_table, addresses_table).where(users_table.c.id == addresses_table.c.user_id)
result = connection.execute(select_stmt)
users_addresses = result.fetchall()

for user, address in users_addresses:
    print(user.name, address.address)
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship

class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey('users.id'))
    address = Column(String(200))
    user = relationship("User", back_populates="addresses") # Define relationship with User

User.addresses = relationship("Address", back_populates="user")

Base.metadata.create_all(engine)

# Select users and their addresses
users = session.query(User).all()

for user in users:
    for address in user.addresses:
        print(user.name, address.address)
            

              
                Copy
              
            
          

Core gadījumā jūs skaidri norādāt savienošanas nosacījumu, izmantojot `where` klauzulu. Jūs iegūstat rezultātus kā kortežus un piekļūstat kolonnām pēc indeksa. ORM gadījumā jūs definējat attiecības starp `User` un `Address` klasēm, izmantojot `relationship` funkciju. Tas ļauj jums piekļūt adresēm, kas saistītas ar lietotāju, tieši caur `user.addresses` atribūtu. ORM netieši apstrādā savienojumu. `back_populates` arguments uztur abas attiecību puses sinhronizētas.

Datu ievietošana

SQLAlchemy Core:

            from sqlalchemy import insert

# Insert a new user
insert_stmt = insert(users_table).values(name='Bob', email='bob@example.com')
result = connection.execute(insert_stmt)

# Get the ID of the newly inserted row
inserted_id = result.inserted_primary_key[0]
print(f"Inserted user with ID: {inserted_id}")
connection.commit()
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Insert a new user
new_user = User(name='Bob', email='bob@example.com')
session.add(new_user)
session.commit()

# Get the ID of the newly inserted row
print(f"Inserted user with ID: {new_user.id}")
            

              
                Copy
              
            
          

Core gadījumā jūs izmantojat `insert` funkciju un norādāt ievietojamās vērtības. Lai saglabātu izmaiņas, jums ir jāapstiprina transakcija (commit). ORM gadījumā jūs izveidojat `User` objektu, pievienojat to sesijai un apstiprināt sesiju. ORM automātiski izseko izmaiņām un apstrādā ievietošanas procesu. Piekļūstot `new_user.id` pēc apstiprināšanas, tiek iegūta piešķirtā primārā atslēga.

Datu atjaunināšana

SQLAlchemy Core:

            from sqlalchemy import update

# Update the email of user with ID 1
update_stmt = update(users_table).where(users_table.c.id == 1).values(email='new_email@example.com')
result = connection.execute(update_stmt)
print(f"Updated {result.rowcount} rows")
connection.commit()
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Update the email of user with ID 1
user = session.query(User).filter(User.id == 1).first()
if user:
    user.email = 'new_email@example.com'
    session.commit()
    print("User updated successfully")
else:
    print("User not found")
            

              
                Copy
              
            
          

Core gadījumā jūs izmantojat `update` funkciju un norādāt atjaunināmās kolonnas un `where` klauzulu. Jums ir jāapstiprina transakcija. ORM gadījumā jūs iegūstat `User` objektu, modificējat tā atribūtus un apstiprināt sesiju. ORM automātiski izseko izmaiņām un atjaunina atbilstošo rindu datubāzē.

Datu dzēšana

SQLAlchemy Core:

            from sqlalchemy import delete

# Delete user with ID 1
delete_stmt = delete(users_table).where(users_table.c.id == 1)
result = connection.execute(delete_stmt)
print(f"Deleted {result.rowcount} rows")
connection.commit()
            

              
                Copy
              
            
          

SQLAlchemy ORM:

            # Delete user with ID 1
user = session.query(User).filter(User.id == 1).first()
if user:
    session.delete(user)
    session.commit()
    print("User deleted successfully")
else:
    print("User not found")
            

              
                Copy
              
            
          

Core gadījumā jūs izmantojat `delete` funkciju un norādāt `where` klauzulu. Jums ir jāapstiprina transakcija. ORM gadījumā jūs iegūstat `User` objektu, izdzēšat to no sesijas un apstiprināt sesiju. ORM apstrādā dzēšanas procesu.

Veiktspējas apsvērumi

SQLAlchemy Core parasti piedāvā labāku veiktspēju sarežģītiem vaicājumiem, jo tas ļauj tieši rakstīt augsti optimizētus SQL priekšrakstus. Ir mazāk papildu slodzes, kas saistīta ar objektorientētu operāciju tulkošanu uz SQL. Tomēr tas prasa lielākas izstrādes pūles. Tīrs SQL dažkārt var būt specifisks konkrētai datubāzei un mazāk pārnēsājams.

SQLAlchemy ORM var būt lēnāks noteiktām operācijām, jo ir papildu slodze, kas saistīta ar objektu kartēšanu uz datubāzes rindām un otrādi. Tomēr daudzos izplatītos lietošanas gadījumos veiktspējas atšķirība ir nenozīmīga, un vienkāršotās izstrādes priekšrocības atsver veiktspējas izmaksas. ORM arī nodrošina kešatmiņas mehānismus, kas dažos scenārijos var uzlabot veiktspēju. Izmantojot tādas metodes kā "eager loading" (`joinedload`, `subqueryload`), var ievērojami optimizēt veiktspēju, strādājot ar saistītiem objektiem.

Kompromisi:

• Core: Ātrāks izpildes ātrums, lielāka kontrole, stāvāka mācīšanās līkne, izvērstāks kods.
• ORM: Lēnāks izpildes ātrums (potenciāli), mazāka kontrole, vieglāk iemācīties, kodolīgāks kods.

Elastības apsvērumi

SQLAlchemy Core nodrošina maksimālu elastību, jo jums ir pilnīga kontrole pār SQL priekšrakstiem. Tas ir īpaši svarīgi, strādājot ar sarežģītiem vaicājumiem, datubāzei specifiskām funkcijām vai veiktspējas kritiskām operācijām. Jūs varat tieši izmantot uzlabotas SQL funkcijas, piemēram, logu funkcijas, kopīgās tabulu izteiksmes (CTE) un saglabātās procedūras.

SQLAlchemy ORM piedāvā mazāku elastību, jo tas abstrahē pamatā esošo SQL. Lai gan tas atbalsta daudzas izplatītas SQL funkcijas, tas var nebūt piemērots ļoti specializētām vai datubāzei specifiskām operācijām. Jums var nākties pāriet uz Core noteiktiem uzdevumiem, ja ORM nenodrošina nepieciešamo funkcionalitāti. SQLAlchemy ļauj jaukt un saskaņot Core un ORM vienā un tajā pašā lietojumprogrammā, nodrošinot labāko no abām pasaulēm.

Lietošanas ērtuma apsvērumi

SQLAlchemy ORM parasti ir vieglāk lietojams nekā SQLAlchemy Core, īpaši vienkāršām CRUD (Create, Read, Update, Delete) operācijām. Objektorientētā pieeja vienkāršo izstrādi un samazina šablona koda daudzumu. Jūs varat koncentrēties uz lietojumprogrammas loģiku, nevis uz SQL sintakses detaļām.

SQLAlchemy Core prasa dziļāku izpratni par SQL un datubāzu konceptiem. Tas var būt izvērstāks un prasīt vairāk koda, lai paveiktu tos pašus uzdevumus kā ORM. Tomēr tas arī sniedz jums lielāku kontroli un pārredzamību pār datubāzes mijiedarbību.

Kad lietot Core un kad ORM

Lietojiet SQLAlchemy Core, ja:

• Jums nepieciešama maksimāla veiktspēja un kontrole pār SQL.
• Jūs strādājat ar sarežģītiem vaicājumiem vai datubāzei specifiskām funkcijām.
• Jums ir laba izpratne par SQL un datubāzu konceptiem.
• Objektu kartēšanas papildu slodze nav pieņemama.
• Jūs strādājat ar mantotu datubāzi ar sarežģītām shēmām.

Lietojiet SQLAlchemy ORM, ja:

• Jūsu prioritāte ir lietošanas ērtums un ātra izstrāde.
• Jūs strādājat pie jaunas lietojumprogrammas ar labi definētu objektu modeli.
• Jums nepieciešams vienkāršot bieži veicamās CRUD operācijas.
• Veiktspēja nav galvenā problēma (vai to var optimizēt ar kešatmiņu un "eager loading").
• Jūs vēlaties izmantot objektorientētas funkcijas, piemēram, iekapsulēšanu un mantošanu.

Reālās pasaules piemēri un apsvērumi

Apskatīsim dažus reālās pasaules scenārijus un to, kā izvēli starp Core un ORM varētu ietekmēt:

1. E-komercijas platforma: E-komercijas platforma, kas pārvalda miljoniem produktu un klientu darījumu, varētu gūt labumu no SQLAlchemy Core izmantošanas tās galvenajā datu piekļuves slānī, īpaši veiktspējas kritiskos vaicājumos, piemēram, produktu meklēšanā un pasūtījumu apstrādē. ORM varētu izmantot mazāk kritiskām operācijām, piemēram, lietotāju profilu un produktu kategoriju pārvaldībai.

2. Datu analīzes lietojumprogramma: Datu analīzes lietojumprogramma, kurai nepieciešamas sarežģītas agregācijas un datu transformācijas, visticamāk, gūtu labumu no SQLAlchemy Core, kas ļauj veidot augsti optimizētus SQL vaicājumus un izmantot datubāzei specifiskas analītiskās funkcijas.

3. Satura pārvaldības sistēma (CMS): CMS, kas pārvalda rakstus, lapas un multivides failus, varētu efektīvi izmantot SQLAlchemy ORM savām satura pārvaldības funkcijām, vienkāršojot satura izveidi, rediģēšanu un izgūšanu. Core varētu izmantot pielāgotām meklēšanas funkcionalitātēm vai sarežģītām satura attiecībām.

4. Finanšu tirdzniecības sistēma: Augstas frekvences tirdzniecības sistēma gandrīz noteikti izmantotu SQLAlchemy Core, ņemot vērā ekstrēmo jutību pret aizkavi un nepieciešamību pēc precīzas kontroles pār datubāzes mijiedarbību. Katra mikrosekunde ir svarīga!

5. Sociālo mediju platforma: Sociālo mediju platforma varētu izmantot hibrīda pieeju. ORM lietotāju kontu, ziņu un komentāru pārvaldībai, un Core sarežģītiem grafu vaicājumiem, lai atrastu savienojumus starp lietotājiem vai analizētu tendences.

Internacionalizācijas apsvērumi: Projektējot datubāzu shēmas globālām lietojumprogrammām, apsveriet iespēju izmantot Unicode datu tipus (piem., `NVARCHAR`), lai atbalstītu vairākas valodas. SQLAlchemy caurspīdīgi apstrādā Unicode kodējumu. Tāpat apsveriet iespēju uzglabāt datumus un laikus standartizētā formātā (piem., UTC) un konvertēt tos uz lietotāja vietējo laika joslu lietojumprogrammas slānī.

Secinājums

SQLAlchemy Core un ORM piedāvā atšķirīgas pieejas datubāzes mijiedarbībai, katrai ar savām stiprajām un vājajām pusēm. SQLAlchemy Core nodrošina maksimālu veiktspēju un elastību, savukārt SQLAlchemy ORM vienkāršo izstrādi un piedāvā objektorientētu pieeju. Izvēle starp Core un ORM ir atkarīga no jūsu lietojumprogrammas specifiskajām prasībām. Daudzos gadījumos hibrīda pieeja, kas apvieno gan Core, gan ORM stiprās puses, ir labākais risinājums. Izpratne par katras pieejas niansēm ļaus jums pieņemt pamatotus lēmumus un veidot robustas un efektīvas datubāzes lietojumprogrammas. Atcerieties apsvērt veiktspējas ietekmi, elastības prasības un lietošanas ērtumu, izvēloties starp SQLAlchemy Core un ORM.